package com.ht.web_vr_home_tour_backend.utils;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.ht.web_vr_home_tour_backend.config.data.RedisConstants;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.function.Function;

/**
 * 缓存操作工具类
 * @author atrix
 * @since 2024年9月8日
 */
@Component
@Slf4j
public class CacheClient {
    @Autowired
    private RedissonClient redissonClient;

    private final StringRedisTemplate stringRedisTemplate;

    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    /**
     * 将数据保存只Redis缓存
     *
     * @param key  数据键
     * @param data 数据对象
     * @param time 缓存过期时间
     */
    public void set(String key, Object data, Long time) {
        String jsonData = JSONUtil.toJsonStr(data);
        stringRedisTemplate.opsForValue().set(key, jsonData, time, RedisConstants.timeUnit);
    }

    /**
     * 从缓存中读取数据
     * 通过写入空值解决缓存穿透问题
     * 通过互斥方案解决缓存击穿问题
     *
     * @param dataType   数据的类型
     * @param keyPrefix  缓存key的前缀
     * @param id         id
     * @param dbFallback 查询数据库的方法
     * @param time       缓存过期时间
     * @param <T>        数据的类型
     * @return 查询到的数据
     */
    public <T> T queryWithMutex(
            Class<T> dataType,
            String keyPrefix,
            String id,
            Function<String, T> dbFallback,
            Long time) {
        String key = keyPrefix + id;
        T data = null;
        RLock lock = redissonClient.getLock("key:" + key);
        try {
            data = getDataFromCache(key, dataType);
            return data;
        } catch (EmptyDataException emptyDataException) {
            try {
                // 缓存未命中，获取锁，实现缓存重建
                lock.lock(10L, RedisConstants.timeUnit);
                try {
                    // 二次查询缓存，如果有其他线程重构了缓存，则直接返回查到的数据
                    // 如果缓存依然没有数据，则进行重构
                    data = getDataFromCache(key, dataType);
                } catch (EmptyDataException emptyDataException1) {
                    data = dbFallback.apply(id);
                    if (data == null) {
                        // 查询为空，则将空值写入redis防止内存穿透
                        stringRedisTemplate.opsForValue().set(
                                key,
                                "",
                                RedisConstants.CACHE_NULL_TTL,
                                RedisConstants.timeUnit);
                    } else {
                        // 查询到数据，将数据写入缓存
                        this.set(key, data, time);
                    }
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
            return data;
        }
    }

    public void dropCache(String keyPrefix, String id) {
        stringRedisTemplate.delete(keyPrefix + id);
    }

    /**
     * 通过输入的key从缓存中查找数据，如果找到则直接返回对象，
     * 如果找到空字符串，则认为数据库中并没有该数据，返回空对象，
     * 抛出异常，证明缓存中没有找到该数据，需要从数据库中查找进行缓存重写
     *
     * @param key 缓存对象key
     * @return 缓存的对象
     */
    private <T> T getDataFromCache(String key, Class<T> dataType) throws EmptyDataException {
        String json = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(json)) {
            // 缓存命中，直接返回
            return JSONUtil.toBean(json, dataType);
        } else {
            if (json != null) {
                // 缓存命中，但数据不存在
                return null;
            }
            // 缓存未命中
            throw new EmptyDataException();
        }
    }

    /**
     * 自定义异常（如果缓存未命中抛出）
     */
    private static class EmptyDataException extends Exception {
    }
}